Grokking Microservices Design Patterns
Rate this course
Ask Author
Contribute
Back to course home

0% completed

Vote For New Content
Introduction
Who Should Take This Course?
The Course at a Glance
Strangler Fig Pattern
Introduction
The Problem: Legacy Systems
The Strangler Pattern: A Solution
The Architecture of the Strangler Pattern
Strangler Pattern: A Detailed Example
Key Insights and Implications
Introduction to the API Gateway Pattern
Advantages of API Gateway Pattern
API Gateway Pattern: An Example
Performance Implications
System Design Example
Introduction to BFF
The Problem: Traditional Backend Models
The Architecture of the BFF Pattern
BFF Pattern: An Example
Performance Implications
System Design Examples
What is Service Discovery Pattern?
The Problem: Service Coordination in Distributed Systems
Service Discovery Pattern: A Solution
The Architecture of the Service Discovery Pattern
The Inner Workings of the Service Discovery Pattern
Service Discovery Pattern: An Example
Performance Implications and Special Considerations
System Design Examples
Security Considerations
Introduction
The Problem: The Struggles of Distributed Systems and Service Failures
The Circuit Breaker Pattern: An Effective Shield Against Cascading Failures
Circuit Breaker Pattern: An Example
Performance Implications and Special Considerations
System Design Examples
Summary
Introduction
The Problem: Failure Propagation in Distributed Systems
The Bulkhead Pattern: A Solution
The Architecture
The Inner Workings
Bulkhead Pattern: A Example
Performance Implications and Special Considerations
System Design Examples
Conclusion
Introduction
The Retry Pattern: A Solution to Unreliable External Resources
The Architecture of the Retry Pattern
Retry Pattern: An Example
Performance Implications
Use Cases and System Design Examples
Conclusion
Introduction to the Sidecar Pattern
The Problem: Monolithic Application Management
A Solution to the Monolithic Mayhem
The Architecture of the Sidecar Pattern
Sidecar Pattern: Bringing Theory to Practice with an Example
Performance Implications
System Design Examples: Bringing the Sidecar Pattern to Life
Introduction to Saga Pattern
The Problem: Traditional Transaction Models
The Saga Pattern: A Solution
The Architecture of the Saga Pattern
The Inner Workings of the Saga Pattern
Saga Pattern: A Example
Performance Implications
System Design Examples
Conclusion
Introduction
The Problem: Managing Complex Interactions in Distributed Systems
Event-Driven Architecture: A Promising Solution
The Architecture of the Event-Driven Architecture Pattern
The Inner Workings of the Event-Driven Architecture Pattern
Event-Driven Architecture Pattern: An Example
Performance Implications and Special Considerations
Use Cases and System Design Examples
Conclusion
Introduction
The Problem: Traditional CRUD Operations
CQRS Pattern: A Solution
The Architecture of the CQRS Pattern
The Inner Workings of the CQRS Pattern
CQRS Pattern: An Example
Issues, Special Considerations, and Performance Implications
System Design Examples
Introduction
The Problem: Configuration Management in a Microservices Architecture
The Solution: Configuration Externalization Pattern
Unveiling the Architecture: How Does Configuration Externalization Work?
Delving into Code: An Example
Considerations and Implications
Use Cases and Real-world Examples
Conclusion
Embrace the Future of Software Architecture
The Problem: Legacy Systems

What are Legacy System? Legacy systems are old softwares, technologies, tools, or infrastructures used by an organization. They were often introduced ages ago and might be based on outdated technologies, but they continue to provide essential functions, and that's why they've stuck around.

Challenges with Legacy Systems:

  1. Technical Debt: Over the years, patches, fixes, and new features might have been added haphazardly, leading to a complex, hard-to-maintain codebase.

  2. Obsolete Technology: The technology stack may no longer be in vogue, making it difficult to find experts or support.

  3. Integration Issues: Modern tools and services might not easily integrate with older systems, causing silos of information.

  4. Scalability Concerns: Legacy systems might not be designed to handle today's scale or might not be cloud-ready.

  5. Costly Maintenance: As the system ages, maintenance can become more expensive, both in terms of time and resources.

  6. Security Vulnerabilities: Older systems may not have been designed with current security best practices in mind, making them susceptible to attacks.

Why is Replacing Legacy Systems Hard?

  1. Critical Operations: Many legacy systems are deeply embedded in an organization's critical operations. Any disruption can have significant impacts.

  2. Migration Risks: Data migration from old to new systems can be fraught with risks like data loss or corruption.

  3. Training & Adoption: Staff might be used to the old system. Introducing a new system requires training and can face resistance.

  4. High Costs: Building a new system and ensuring it works as reliably as the old one can be expensive.

  5. Unknown Unknowns: There may be undocumented features or behaviors in the legacy system that users have come to rely upon.

Strangler Fig Pattern to the Rescue:

Here is how the strangler fig design pattern helps us replacing the legacy system:

  1. Incremental Replacement: Instead of a big bang approach, replace the legacy system piece by piece. This reduces risks and allows for iterative feedback.

  2. Coexistence: The new and old systems run side-by-side. As features are moved to the new system, traffic is rerouted accordingly, ensuring operations continue without disruption.

  3. Feedback Loops: By gradually transitioning users, feedback can be obtained early and often. This ensures the new system meets user needs.

  4. Reduced Risk: If a part of the new system has issues, it's easier to revert changes or fix them without affecting the entire system.

  5. Flexibility: The pattern provides flexibility in adopting new technologies. As the industry evolves, the new system can evolve with it.

  6. End Goal: Over time, the legacy system's functionality is entirely replaced by the new system. Once the old system has no more active users or features, it can be safely retired.

Introduction
The Strangler Pattern: A Solution
Mark as Completed

On this page

Challenges with Legacy Systems:

Why is Replacing Legacy Systems Hard?

Strangler Fig Pattern to the Rescue: